{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.296570\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "**Your answer:** For each L_i, it can be estimated to -log(exp(0)/exp(0)*10), which is -log(0.1).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 0.093735 analytic: 0.093735, relative error: 7.394185e-07\n",
      "numerical: -2.391284 analytic: -2.391284, relative error: 6.666679e-09\n",
      "numerical: 1.347638 analytic: 1.347638, relative error: 1.830261e-08\n",
      "numerical: 0.565054 analytic: 0.565054, relative error: 8.203440e-08\n",
      "numerical: -3.718024 analytic: -3.718024, relative error: 3.405267e-08\n",
      "numerical: -1.664673 analytic: -1.664673, relative error: 8.046240e-09\n",
      "numerical: 0.452313 analytic: 0.452313, relative error: 4.574203e-09\n",
      "numerical: -1.563130 analytic: -1.563130, relative error: 8.867197e-09\n",
      "numerical: -0.148547 analytic: -0.148547, relative error: 5.556806e-07\n",
      "numerical: -0.354350 analytic: -0.354350, relative error: 1.123198e-07\n",
      "numerical: -1.040512 analytic: -1.040512, relative error: 2.995416e-08\n",
      "numerical: -1.403806 analytic: -1.403806, relative error: 6.996501e-09\n",
      "numerical: 1.126977 analytic: 1.126977, relative error: 1.558301e-08\n",
      "numerical: -3.879256 analytic: -3.879256, relative error: 9.576199e-09\n",
      "numerical: 0.985894 analytic: 0.985894, relative error: 2.440505e-08\n",
      "numerical: -1.575829 analytic: -1.575829, relative error: 1.048370e-08\n",
      "numerical: -0.621181 analytic: -0.621181, relative error: 2.026289e-08\n",
      "numerical: 0.624596 analytic: 0.624596, relative error: 3.664283e-08\n",
      "numerical: 0.265122 analytic: 0.265122, relative error: 1.132569e-07\n",
      "numerical: 1.718354 analytic: 1.718354, relative error: 2.952872e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.296571e+00 computed in 0.115648s\n",
      "vectorized loss: 2.296571e+00 computed in 0.013300s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 2.000000e-07 reg 1.000000e+02 train accuracy: 0.272531 val accuracy: 0.278000\n",
      "lr 2.000000e-07 reg 5.000000e+02 train accuracy: 0.278939 val accuracy: 0.276000\n",
      "lr 2.000000e-07 reg 1.000000e+03 train accuracy: 0.301735 val accuracy: 0.296000\n",
      "lr 2.000000e-07 reg 5.000000e+03 train accuracy: 0.368163 val accuracy: 0.378000\n",
      "lr 2.000000e-07 reg 1.000000e+04 train accuracy: 0.356429 val accuracy: 0.362000\n",
      "lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.314633 val accuracy: 0.334000\n",
      "lr 5.000000e-07 reg 1.000000e+02 train accuracy: 0.316184 val accuracy: 0.315000\n",
      "lr 5.000000e-07 reg 5.000000e+02 train accuracy: 0.346959 val accuracy: 0.341000\n",
      "lr 5.000000e-07 reg 1.000000e+03 train accuracy: 0.373408 val accuracy: 0.378000\n",
      "lr 5.000000e-07 reg 5.000000e+03 train accuracy: 0.368755 val accuracy: 0.388000\n",
      "lr 5.000000e-07 reg 1.000000e+04 train accuracy: 0.353551 val accuracy: 0.364000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.312837 val accuracy: 0.326000\n",
      "lr 1.000000e-06 reg 1.000000e+02 train accuracy: 0.358143 val accuracy: 0.346000\n",
      "lr 1.000000e-06 reg 5.000000e+02 train accuracy: 0.392449 val accuracy: 0.383000\n",
      "lr 1.000000e-06 reg 1.000000e+03 train accuracy: 0.398592 val accuracy: 0.409000\n",
      "lr 1.000000e-06 reg 5.000000e+03 train accuracy: 0.361776 val accuracy: 0.369000\n",
      "lr 1.000000e-06 reg 1.000000e+04 train accuracy: 0.342551 val accuracy: 0.360000\n",
      "lr 1.000000e-06 reg 5.000000e+04 train accuracy: 0.297000 val accuracy: 0.310000\n",
      "best validation accuracy achieved during cross-validation: 0.409000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [2e-7, 5e-7, 1e-6]\n",
    "regularization_strengths = [1e2, 5e2, 1e3, 5e3, 1e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for learning_rate in learning_rates:\n",
    "  for reg in regularization_strengths:\n",
    "    softmax = Softmax()\n",
    "    softmax.train(X_train, y_train, learning_rate=learning_rate, reg=reg,\n",
    "                  num_iters=1200, verbose=False)\n",
    "    y_train_pred = softmax.predict(X_train)\n",
    "    y_train_acc = np.mean(y_train == y_train_pred)\n",
    "    y_val_pred = softmax.predict(X_val)\n",
    "    y_val_acc = np.mean(y_val == y_val_pred)\n",
    "    results[(learning_rate, reg)] = (y_train_acc, y_val_acc)\n",
    "\n",
    "    if y_val_acc > best_val:\n",
    "      best_val = y_val_acc\n",
    "      best_softmax = softmax\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.389000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
